
/** 
 * 构造一个由所需的 T 的键组成的类型。
 * 
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age?: number;
 *   email?: string;
 * }
 * 
 * type RequiredUserKeys = RequiredKeys<User>;
* ```
* RequiredUserKeys 相当于：
 * * 'name'
*/
export declare type RequiredKeys<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? never : K
}[keyof T];


/**
 * 构造 T 的所有属性都设置为可变的类型。
 *
 * @example
 * ```ts
 * interface User {
 *   readonly name: string;
 *   readonly age: number;
 * }
 *
 * type MutableUser = Mutable<User>;
 * ```
 * 
 * MutableUser 相当于：
 * 
 * ```ts
 * {
 *   name: string;
 *   age: number;
 * }
 * ```
 */
export declare type Mutable<T> = {
    -readonly [P in keyof T]: T[P];
};

export declare type Nullable<T> = T | null;

/**
 * 构造T的所有属性都设置为 required 的类型，k中指定的属性除外。
 *
 * @example
 * ```ts
 * interface User {
 *   name?: string;
 *   age?: number;
 *   email?: string;
 * }
 *
 * type RequiredUserExceptEmail = RequiredExcept<User, 'email'>;
 * ```
 * 
 * RequiredUserExceptEmail 相当于：
 * 
 * ```ts
 * {
 *   name: string;
 *   age: number;
 *   email?: string;
 * }
 * ```
 */
export declare type RequiredExcept<T, K extends keyof T> = {
    [P in keyof T]-?: P extends K ? T[P] : NonNullable<T[P]>;
};

/** 
 * 构造 T 的所有属性都设置为 readonly 的类型，K中指定的属性除外。
 *
 * @example
 * ```ts
 * interface User {
 *   readonly name: string;
 *   readonly age: number;
 *   readonly email: string;
 * }
 *
 * type MutableUserExceptEmail = ReadonlyExcept<User, 'email'>;
 * ```
 * 
 * MutableUserExceptEmail 相当于：
 * 
 * ```ts
 * {
 *    readonly name: string;
 *    readonly age: number;
 *    email: string;
 * }
 * ```
 */
export declare type ReadonlyExcept<T, K extends keyof T> = {
    readonly [P in keyof T]-?: P extends K ? T[P] : T[P];
};

/**
 * 构造一个类型，其中 T 的所有属性都设置为可变，K 中指定的属性除外。
 *
 * @example
 * ```ts
 * interface User {
 *   readonly name: string;
 *   readonly age: number;
 *   readonly email: string;
 * }
 *
 * type MutableUserExceptEmail = MutableExcept<User, 'email'>;
 * ```
 * 
 * MutableUserExceptEmail 相当于：
 * 
 * ```ts
 * {
 *   name: string;
 *   age: number;
 *   email: string;
 * }
 * ```
 */
export declare type MutableExcept<T, K extends keyof T> = {
    -readonly [P in keyof T]-?: P extends K ? T[P] : T[P];
};

/**
 * 通过选取值为 V 类型的 T 的属性来构造类型。
 *
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age: number;
 *   email: string | null;
 * }
 *
 * type UserWithEmail = PickByValue<User, string>;
 * ```
 * 
 * UserWithEmail 相当于：
 * 
 * ```ts
 * {
 *   name: string;
 *   email: string | null;
 * }
 * ```
 */
export declare type PickByValue<T, V> = Pick<T, { [P in keyof T]-?: T[P] extends V ? P : never }[keyof T]>;

/**
 * 通过省略 T 的值为 V 类型的属性来构造类型。
 *
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age: number;
 *   email: string | null;
 * }
 *
 * type UserWithoutEmail = OmitByValue<User, string | null>;
 * ```
 * 
 * UserWithoutEmail 相当于：
 * 
 * ```ts
 * {
 *   age: number;
 * }
 * ```
 */
export declare type OmitByValue<T, V> = Pick<T, { [P in keyof T]-?: T[P] extends V ? never : P }[keyof T]>;

/**
 * 构造一个由 T 和 U 中的所有属性组成的类型。
 *
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age: number;
 * }
 *
 * interface Admin {
 *   name: string;
 *   age: number;
 *   role: string;
 * }
 *
 * type UserAndAdmin = Intersection<User, Admin>;
 * ```
 * 
 * UserAndAdmin 相当于：
 * 
 * ```ts
 * {
 *   name: string;
 *   age: number;
 * }
 * ```
 */
export declare type Intersection<T, U> = Pick<T & U, keyof T & keyof U>;

/**
 * Diff<T, U>
 * Constructs a type consisting of all properties that are in T but not in U.
 *
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age: number;
 * }
 *
 * interface Admin {
 *   name: string;
 *   age: number;
 *   role: string;
 * }
 *
 * type UserWithoutAdmin = Diff<User, Admin>;
 * ```
 * 
 * UserWithoutAdmin 相当于：
 * 
 * ```ts
 * {
 *   name: string;
 *   age: number;
 * }
 * ```
 */
export declare type Diff<T, U> = Pick<T, Exclude<keyof T, keyof U>>;


/**
 * 构造一个类型，由T中但不在 T 和 U 的交集中的所有属性组成。
 *
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age: number;
 *   email: string;
 * }
 *
 * interface Admin {
 * name: string;
 * age: number;
 * role: string;
 * }
 * 
 * type UserWithoutCommon = Subtract<User, Admin>;
 * ```
 * 
 * UserWithoutCommon 相当于：
 * 
 * ```ts
 * {
 *   email: string;
 * }
 * ```
 */
export declare type Subtract<T, U> = Pick<T, Exclude<keyof T, keyof U>>;

/**
 * 构造一个由 T 和 U 的所有属性组成的类型，其中 U 的属性覆盖 T 的同名属性。
 *
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age: number;
 * }
 *
 * interface PartialUser {
 *   name?: string;
 * }
 *
 * type UserWithPartial = Overwrite<User, PartialUser>;
 * ```
 * 
 * UserWithPartial 相当于：
 * 
 * ```ts
 * {
 *   name?: string;
 *   age: number;
 * }
 * ```
 */
export declare type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;

/**
 * 构造一个类型，该类型由 T 中所有类型的交集中的所有属性组成。
 *
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age: number;
 * }
 *
 * interface Admin {
 *   name: string;
 *   role: string;
 * }
 *
 * type UserAndAdminIntersection = UnionToIntersection<User | Admin>;
 * ```
 * 
 * UserAndAdminIntersection 相当于：
 * 
 * ```ts
 * {
 *   name: string;
 * }
 * ```
 */
export declare type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;

/**
 * 构造一个由T的键组成的类型，这些键是函数。
 *
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age: number;
 *   greet(): void;
 * }
 *
 * type UserFunctionKeys = FunctionKeys<User>;
 * ```
 * 
 * UserFunctionKeys 相当于：
 * 
 * ```ts
 * 'greet'
 * ```
 */
export declare type FunctionKeys<T> = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];

/**
 * 构造一个由 T 的非函数键组成的类型。
 *
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age: number;
 *   greet(): void;
 * }
 *
 * type UserNonFunctionKeys = NonFunctionKeys<User>;
 * ```
 * 
 * UserNonFunctionKeys 相当于：
 * 
 * ```ts
 * 'name' | 'age'
 * ```
 */
export declare type NonFunctionKeys<T> = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T];

/**
 * 构造一个由 Promise-like 类型 T 的已解析类型组成的类型。
 *
 * @example
 * ```ts
 * type User = {
 *   name: string;
 *   age: number;
 * };
 *
 * type UserPromise = Promise<User>;
 *
 * type UserResolved = PromiseType<UserPromise>;
 * ```
 * 
 * UserResolved 相当于：
 * 
 * ```ts
 * {
 *   name: string;
 *   age: number;
 * }
 * ```
 */
export declare type PromiseType<T extends Promise<any>> = T extends Promise<infer U> ? U : never;

/**
 * 构造一个 T 的所有属性都递归设置为只读的类型。
 *
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age: number;
 *   address: {
 *     street: string;
 *     city: string;
 *   };
 * }
 *
 * type DeepReadonlyUser = DeepReadonly<User>;
 * ```
 * 
 * DeepReadonlyUser 相当于：
 * 
 * ```ts
 * {
 *   readonly name: string;
 *   readonly age: number;
 *   readonly address: {
 *     readonly street: string;
 *     readonly city: string;
 *   };
 * }
 * ```
 */
export declare type DeepReadonly<T> = {
    readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};

/**
 * 递归地构造 T 的所有属性都设置为可选的类型。
 *
 * @example
 * ```ts
 * interface User {
 * name: string;
 * age: number;
 * address: {
 *   street: string;
 *   city: string;
 *   };
 * }
 *
 * type DeepPartialUser = DeepPartial<User>;
 * ```
 * 
 * DeepPartialUser 相当于：
 * 
 * ```ts
 * {
 *   name?: string;
 *   age?: number;
 *   address?: {
 *     street?: string;
 *     city?: string;
 *   };
 * }
 */
export declare type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

/**
 * 构造由 T 中所有值的并集组成的类型。
 *
 * @example
 * ```ts
 * type User = {
 *   id: number;
 *   name: string;
 * };
 *
 * type UserValues = ValueOf<User>;
 * ```
 * 
 * UserValues 相当于：
 * 
 * ```ts
 * number | string
 * ```
 */
export declare type ValueOf<T> = T[keyof T];

/**
 * 构造一个由 T 的可选键组成的类型。
 *
 * @example
 * ```ts
 * interface User {
 *   id: number;
 *   name: string;
 *   age?: number;
 * }
 *
 * type UserOptionalKeys = OptionalKeys<User>;
 * ```
 * 
 * UserOptionalKeys 相当于：
 * 
 * ```ts
 * 'age'
 * ```
 */
export declare type OptionalKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? K : never }[keyof T];

/**
 * 构造一个由 T 的只读键组成的类型。
 *
 * @example
 * ```ts
 * interface User {
 *   readonly id: number;
 *   name: string;
 *   age?: number;
 * }
 *
 * type UserReadonlyKeys = ReadonlyKeys<User>;
 * ```
 * 
 * UserReadonlyKeys 相当于：
 * 
 * ```ts
 * 'id'
 * ```
 */
export declare type ReadonlyKeys<T> = { [K in keyof T]-?: T[K] extends Readonly<T[K]> ? K : never }[keyof T];

/**
 * 构造一个由 T 的可写键组成的类型。
 *
 * @example
 * ```ts
 * interface User {
 *   readonly id: number;
 *   name: string;
 *   age?: number;
 * }
 *
 * type UserWritableKeys = WritableKeys<User>;
 * ```
 * 
 * UserWritableKeys 相当于：
 * 
 * ```ts
 * 'name' | 'age'
 * ```
 */
export declare type WritableKeys<T> = { [K in keyof T]-?: T[K] extends Readonly<T[K]> ? never : K }[keyof T];

/**
 * 递归地构造 T 的所有属性都设置为 required 的类型。
 *
 * @example
 * ```ts
 * interface User {
 *   name?: string;
 *   age?: number;
 *   address?: {
 *     street?: string;
 *     city?: string;
 *   };
 * }
 *
 * type DeepRequiredUser = DeepRequired<User>;
 * ```
 * 
 * DeepRequiredUser 相当于：
 * 
 * ```ts
 * {
 *   name: string;
 *   age: number;
 *   address: {
 *     street: string;
 *     city: string;
 *   };
 * }
 * ```
 */
export declare type DeepRequired<T> = {
    [P in keyof T]-?: T[P] extends object ? DeepRequired<T[P]> : T[P];
};

/**
 * 构造 T 的所有属性都设置为可递归写的类型。
 *
 * @example
 * ```ts
 * interface User {
 *   readonly name?: string;
 *   readonly age?: number;
 *   readonly address?: {
 *     readonly street?: string;
 *     readonly city?: string;
 *   };
 * }
 *
 * type DeepWritableUser = DeepWritable<User>;
 * ```
 * 
 * DeepWritableUser 相当于：
 * 
 * ```ts
 * {
 *   name?: string;
 *   age?: number;
 *   address?: {
 *     street?: string;
 *     city?: string;
 *   };
 * }
 * ```
 */
export declare type DeepWritable<T> = {
    -readonly [P in keyof T]-?: T[P] extends object ? DeepWritable<T[P]> : T[P];
};

/**
 * 构造一个类型，其中 T 的所有属性都递归地设置为 non-nullable。
 *
 * @example
 * ```ts
 * interface User {
 *   name?: string;
 *   age?: number | null;
 *   address?: {
 *     street?: string;
 *     city?: string | null;
 *   };
 * }
 *
 * type DeepNonNullableUser = DeepNonNullable<User>;
 * ```
 * 
 * DeepNonNullableUser 相当于：
 * 
 * ```ts
 * {
 *   name: string;
 *   age: number;
 *   address: {
 *     street: string;
 *     city: string;
 *   };
 * }
 * ```
 */
export declare type DeepNonNullable<T> = {
    [P in keyof T]-?: NonNullable<T[P]> extends object ? DeepNonNullable<NonNullable<T[P]>> : NonNullable<T[P]>;
};

/**
 * 构造 T 的所有属性都设置为不可变的类型。
 *
 * @example
 * ```ts
 * interface User {
 * name: string;
 * age: number;
 * }
 *
 * type ImmutableUser = Immutable<User>;
 * ```
 * 
 * ImmutableUser 相当于：
 * 
 * ```ts
 * {
 *   readonly name: string;
 *   readonly age: number;
 * }
 * ```
 */
export declare type Immutable<T> = {
    +readonly [P in keyof T]: T[P];
};

/**
 * 构造 T 中所有可能的性质排列的联合类型。
 *
 * @example
 * ```ts
 * interface User {
 * id: number;
 * name: string;
 * age: number;
 * }
 *
 * type UserUnion = Unionize<User>;
 * ```
 * 
 * UserUnion 相当于：
 * 
 * ```ts
 * {
 *   id: number;
 * } | {
 *   id: number;
 *   name: string;
 * } | {
 *   id: number;
 *   age: number;
 * } | {
 *   id: number;
 *   name: string;
 *   age: number;
 * }
 * ```
 */
export declare type Unionize<T> = T extends any ? (k: T) => void : never extends (k: infer U) => void ? U : never;


/**
 * 通过从 T 中挑选所有不属于 T 或 U 的属性来构造类型。
 *
 * @example
 * ```ts
 * interface User {
 *   id: number;
 *   name: string;
 *   age: number;
 * }
 *
 * type UserWithNameOrEmail = Exclusive<User, { name: any; email: any }>;
 * ```
 * 
 * UserWithNameOrEmail 相当于：
 * 
 * ```ts
 * {
 *   id: number;
 *   name: string;
 *   age: number;
 * } | {
 *   id: number;
 *   email: any;
 * }
 * ```
 */
export declare type Exclusive<T, U> = (Diff<T, U> & U) | (Diff<U, T> & T);

/**
 * 通过从 T 中选取所有也在 U 中的属性来构造类型。
 *
 * @example
 * ```ts
 * interface User {
 *   id: number;
 *   name: string;
 *   age: number;
 * }
 *
 * type UserWithName = Intersect<User, { name: any }>;
 * ```
 * 
 * UserWithName 相当于：
 * 
 * ```ts
 * {
 *   name: string;
 * }
 * ```
 */
export declare type Intersect<T, U> = Pick<T, Extract<keyof T, keyof U> & Extract<keyof U, keyof T>>;

/**
 * 通过从 T 和 U 中选取所有属性并将它们合并在一起来构造一个类型。
 *
 * @example
 * ```ts
 * interface User {
 *   id: number;
 *   name: string;
 *   age: number;
 * }
 *
 * type UserWithEmail = Assign<User, { email: string }>;
 * ```
 * 
 * UserWithEmail 相当于：
 * 
 * ```ts
 * {
 *   id: number;
 *   name: string;
 *   age: number;
 *   email: string;
 * }
 * ```
 */
export declare type Assign<T, U> = T & U;

/**
 * DeepMutable<T>
 * 构造一个 T 的所有属性都设置为可变递归的类型。
 * 
 * @example
 * ```ts
 * interface User {
 *   readonly name?: string;
 *   readonly age?: number;
 *   readonly address?: {
 *     readonly street?: string;
 *     readonly city?: string;
 *   };
 * }
 *
 * type DeepMutableUser = DeepMutable<User>;
 * ```
 * 
 * DeepMutableUser 相当于：
 * 
 * ```ts
 * {
 *   name?: string;
 *   age?: number;
 *   address?: {
 *     street?: string;
 *     city?: string;
 *   };
 * }
 * ```
 */
export declare type DeepMutable<T> = {
    -readonly [P in keyof T]: T[P] extends object ? DeepMutable<T[P]> : T[P];
};

/**
 * 构造一个 T 的所有属性都设置为 Promisable 的类型。
 *
 * @example
 * ```ts
 * interface User {
 *   name: string;
 *   age: number;
 * }
 *
 * type PromisableUser = Promisable<User>;
 * ```
 * 
 * PromisableUser 相当于：
 * 
 * ```ts
 * {
 *   name: Promise<string>;
 *   age: Promise<number>;
 * }
 * ```
 */
export declare type Promisable<T> = {
    [P in keyof T]: Promise<T[P]>;
};


/**
 * 通过用附加的 U 类型包装 T 来构造一个标称类型。
 *
 * @example
 * ```ts
 * type Email = Brand<string, 'email'>;
 * const email: Email = 'john.doe@example.com';
 * ```
 */
export declare type Brand<T, U> = T & { __brand: U };

/**
 * 通过从 T 中选取所有未定义的属性来构造类型。
 *
 * @example
 * ```ts
 * interface User {
 *   name?: string;
 *   age?: number;
 * }
 *
 * type UserWithoutUndefined = NonUndefined<User>;
 * ```
 * 
 * UserWithoutUndefined 相当于：
 *  
 * ```ts
 * {
 *   name: string;
 *   age: number;
 * }
 * ```
 */
export declare type NonUndefined<T> = T extends undefined ? never : T;

/**
 * 构造一个类型，该类型是一个拥有字符串类型键和任意类型值的记录，类似于JavaScript中的对象。
 *
 * @example
 * ```ts
 * const person: Recordable = {
 *   name: 'John',
 *   age: 30,
 *   address: {
 *     city: 'New York',
 *     street: '123 Main St',
 *   },
 * };
 * ```
 * 
 * Recordable 相当于对象字面量类型：
 * 
 * ```ts
 * {
 *   [key: string]: any;
 * }
 * ```
 * 
 * 当然，可以用于更具体的数据类型：
 * 
 * ```ts
 * const fruits: Recordable<number> = {
 *   apple: 2,
 *   banana: 3,
 *   orange: 4,
 * };
 * ```
 */
export declare type Recordable<T = any> = {
    [key: string]: T;
};
// 或者直接声明为： export declare type Recordable<T = any> = Record<string, T>;

/**
 * 构造一个类型，该类型是一个拥有字符串类型键和只读 T 类型值的记录，类似于JavaScript中的对象。
 *
 * @example
 * ```ts
 * const person: ReadonlyRecordable<number> = {
 *   age: 30,
 *   height: 175,
 * };
 * ```
 * 
 * ReadonlyRecordable 相当于只读对象字面量类型：
 * 
 * ```ts
 * {
 *   readonly [key: string]: T;
 * }
 * ```
 * 
 * 当然，可以用于更具体的数据类型：/
 * 
 * ```ts
 * const fruits: ReadonlyRecordable<number> = {
 *   apple: 2,
 *   banana: 3,
 *   orange: 4,
 * };
 * ```
 */
export declare type ReadonlyRecordable<T = any> = {
    readonly [key: string]: T;
};

/**
 * 构造一个类型，该类型是一个拥有字符串类型键和任意类型值的记录，类似于JavaScript中的对象。
 *
 * @example
 * ```ts
 * const obj: Indexable<number> = {
 *   a: 1,
 *   b: 2,
 *   c: 3,
 * };
 * ```
 * 
 * Indexable 相当于对象字面量类型：
 * 
 * ```ts
 * {
 *   [key: string]: T;
 * }
 * ```
 * 
 * 当然，可以用于更具体的数据类型：
 * 
 * ```ts
 * const obj: Indexable<User> = {
 *   john: { name: 'John', age: 30 },
 *   jane: { name: 'Jane', age: 25 },
 * };
 * ```
 */
export declare type Indexable<T = any> = {
    [key: string]: T;
};

/**
 * setTimeout 函数返回的计时器 ID 类型。
 */
export declare type TimeoutHandle = ReturnType<typeof setTimeout>;

/**
 * setInterval 函数返回的计时器 ID 类型。
 */
export declare type IntervalHandle = ReturnType<typeof setInterval>;

/**
 * 表示一个输入元素的状态变化事件。继承自 Event。
 * 
 * @interface ChangeEvent
 * @extends {Event}
 */
export declare interface ChangeEvent extends Event {
    /**
     * 事件的目标元素，即发生变化的输入元素。
     * 
     * @type {HTMLInputElement}
     * @memberof ChangeEvent
     */
    target: HTMLInputElement;
}

/**
 * 表示鼠标滚轮事件。
 * 
 * @interface WheelEvent
 */
export declare interface WheelEvent {
    /**
     * 滚动方向，可能是负数。
     * 
     * @type {number}
     * @memberof WheelEvent
     */
    delta: number;
    /**
     * 事件传播的路径数组，数值以从目标元素到根元素依次增加。
     * 
     * @type {EventTarget[]}
     * @memberof WheelEvent
     */
    path?: EventTarget[];
}
